home *** CD-ROM | disk | FTP | other *** search
# Source Generated with Decompyle++ # File: in.pyc (Python 2.6) '''Regression test. This will find all modules whose name is "test_*" in the test directory, and run them. Various command line options provide additional facilities. Command line options: -v: verbose -- run tests in verbose mode with output to stdout -w: verbose2 -- re-run failed tests in verbose mode -q: quiet -- don\'t print anything except if a test fails -x: exclude -- arguments are tests to *exclude* -s: single -- run only a single test (see below) -S: slow -- print the slowest 10 tests -r: random -- randomize test execution order -f: fromfile -- read names of tests to run from a file (see below) -l: findleaks -- if GC is available detect tests that leak memory -u: use -- specify which special resource intensive tests to run -h: help -- print this text and exit -t: threshold -- call gc.set_threshold(N) -T: coverage -- turn on code coverage using the trace module -D: coverdir -- Directory where coverage files are put -N: nocoverdir -- Put coverage files alongside modules -L: runleaks -- run the leaks(1) command just before exit -R: huntrleaks -- search for reference leaks (needs debug build, v. slow) -M: memlimit -- run very large memory-consuming tests If non-option arguments are present, they are names for tests to run, unless -x is given, in which case they are names for tests not to run. If no test names are given, all tests are run. -T turns on code coverage tracing with the trace module. -D specifies the directory where coverage files are put. -N Put coverage files alongside modules. -s means to run only a single test and exit. This is useful when doing memory analysis on the Python interpreter (which tend to consume too many resources to run the full regression test non-stop). The file /tmp/pynexttest is read to find the next test to run. If this file is missing, the first test_*.py file in testdir or on the command line is used. (actually tempfile.gettempdir() is used instead of /tmp). -f reads the names of tests from the file given as f\'s argument, one or more test names per line. Whitespace is ignored. Blank lines and lines beginning with \'#\' are ignored. This is especially useful for whittling down failures involving interactions among tests. -L causes the leaks(1) command to be run just before exit if it exists. leaks(1) is available on Mac OS X and presumably on some other FreeBSD-derived systems. -R runs each test several times and examines sys.gettotalrefcount() to see if the test appears to be leaking references. The argument should be of the form stab:run:fname where \'stab\' is the number of times the test is run to let gettotalrefcount settle down, \'run\' is the number of times further it is run and \'fname\' is the name of the file the reports are written to. These parameters all have defaults (5, 4 and "reflog.txt" respectively), so the minimal invocation is \'-R ::\'. -M runs tests that require an exorbitant amount of memory. These tests typically try to ascertain containers keep working when containing more than 2 billion objects, which only works on 64-bit systems. There are also some tests that try to exhaust the address space of the process, which only makes sense on 32-bit systems with at least 2Gb of memory. The passed-in memlimit, which is a string in the form of \'2.5Gb\', determines howmuch memory the tests will limit themselves to (but they may go slightly over.) The number shouldn\'t be more memory than the machine has (including swap memory). You should also keep in mind that swap memory is generally much, much slower than RAM, and setting memlimit to all available RAM or higher will heavily tax the machine. On the other hand, it is no use running these tests with a limit of less than 2.5Gb, and many require more than 20Gb. Tests that expect to use more than memlimit memory will be skipped. The big-memory tests generally run very, very long. -u is used to specify which special resource intensive tests to run, such as those requiring large file support or network connectivity. The argument is a comma-separated list of words indicating the resources to test. Currently only the following are defined: all - Enable all special resources. audio - Tests that use the audio device. (There are known cases of broken audio drivers that can crash Python or even the Linux kernel.) curses - Tests that use curses and will modify the terminal\'s state and output modes. lib2to3 - Run the tests for 2to3 (They take a while.) largefile - It is okay to run some test that may create huge files. These tests can take a long time and may consume >2GB of disk space temporarily. network - It is okay to run tests that use external network resource, e.g. testing SSL support for sockets. bsddb - It is okay to run the bsddb testsuite, which takes a long time to complete. decimal - Test the decimal module against a large suite that verifies compliance with standards. compiler - Test the compiler package by compiling all the source in the standard library and test suite. This takes a long time. Enabling this resource also allows test_tokenize to verify round-trip lexing on every file in the test library. subprocess Run all tests for the subprocess module. urlfetch - It is okay to download files required on testing. To enable all resources except one, use \'-uall,-<resource>\'. For example, to run all the tests except for the bsddb tests, give the option \'-uall,-bsddb\'. ''' import cStringIO import getopt import os import random import re import sys import time import traceback import warnings warnings.filterwarnings('ignore', 'hex/oct constants', FutureWarning, '.*test.test_grammar$') if sys.maxint > 2147483647: warnings.filterwarnings('ignore', 'hex/oct constants', FutureWarning, '<string>') for mod in ('ctypes', 'gzip', 'zipfile', 'tarfile', 'encodings.zlib_codec', 'test.test_zipimport', 'test.test_zlib', 'test.test_zipfile', 'test.test_codecs', 'test.string_tests'): warnings.filterwarnings(module = '.*%s$' % (mod,), action = 'ignore', category = ImportWarning) if sys.platform == 'darwin': try: import resource except ImportError: pass (soft, hard) = resource.getrlimit(resource.RLIMIT_STACK) newsoft = min(hard, max(soft, 1024 * 2048)) resource.setrlimit(resource.RLIMIT_STACK, (newsoft, hard)) from test import test_support RESOURCE_NAMES = ('audio', 'curses', 'largefile', 'network', 'bsddb', 'decimal', 'compiler', 'subprocess', 'urlfetch') def usage(code, msg = ''): print __doc__ if msg: print msg sys.exit(code) def main(tests = None, testdir = None, verbose = 0, quiet = False, exclude = False, single = False, randomize = False, fromfile = None, findleaks = False, use_resources = None, trace = False, coverdir = 'coverage', runleaks = False, huntrleaks = False, verbose2 = False, print_slow = False): """Execute a test suite. This also parses command-line options and modifies its behavior accordingly. tests -- a list of strings containing test names (optional) testdir -- the directory in which to look for tests (optional) Users other than the Python test suite will certainly want to specify testdir; if it's omitted, the directory containing the Python test suite is searched for. If the tests argument is omitted, the tests listed on the command-line will be used. If that's empty, too, then all *.py files beginning with test_ will be used. The other default arguments (verbose, quiet, exclude, single, randomize, findleaks, use_resources, trace, coverdir, and print_slow) allow programmers calling main() directly to set the values that would normally be set by flags on the command line. """ test_support.record_original_stdout(sys.stdout) try: (opts, args) = getopt.getopt(sys.argv[1:], 'hvgqxsSrf:lu:t:TD:NLR:wM:', [ 'help', 'verbose', 'quiet', 'exclude', 'single', 'slow', 'random', 'fromfile', 'findleaks', 'use=', 'threshold=', 'trace', 'coverdir=', 'nocoverdir', 'runleaks', 'huntrleaks=', 'verbose2', 'memlimit=']) except getopt.error: msg = None usage(2, msg) if use_resources is None: use_resources = [] for o, a in opts: if o in ('-h', '--help'): usage(0) continue if o in ('-v', '--verbose'): verbose += 1 continue if o in ('-w', '--verbose2'): verbose2 = True continue if o in ('-q', '--quiet'): quiet = True verbose = 0 continue if o in ('-x', '--exclude'): exclude = True continue if o in ('-s', '--single'): single = True continue if o in ('-S', '--slow'): print_slow = True continue if o in ('-r', '--randomize'): randomize = True continue if o in ('-f', '--fromfile'): fromfile = a continue if o in ('-l', '--findleaks'): findleaks = True continue if o in ('-L', '--runleaks'): runleaks = True continue if o in ('-t', '--threshold'): import gc gc.set_threshold(int(a)) continue if o in ('-T', '--coverage'): trace = True continue if o in ('-D', '--coverdir'): coverdir = os.path.join(os.getcwd(), a) continue if o in ('-N', '--nocoverdir'): coverdir = None continue if o in ('-R', '--huntrleaks'): huntrleaks = a.split(':') if len(huntrleaks) != 3: print a, huntrleaks usage(2, '-R takes three colon-separated arguments') if len(huntrleaks[0]) == 0: huntrleaks[0] = 5 else: huntrleaks[0] = int(huntrleaks[0]) if len(huntrleaks[1]) == 0: huntrleaks[1] = 4 else: huntrleaks[1] = int(huntrleaks[1]) if len(huntrleaks[2]) == 0: huntrleaks[2] = 'reflog.txt' len(huntrleaks[2]) == 0 if o in ('-M', '--memlimit'): test_support.set_memlimit(a) continue if o in ('-u', '--use'): u = [ x.lower() for x in a.split(',') ] for r in u: remove = False if r[0] == '-': remove = True r = r[1:] if r not in RESOURCE_NAMES: usage(1, 'Invalid -u/--use option: ' + a) if remove: if r in use_resources: use_resources.remove(r) r in use_resources if r not in use_resources: use_resources.append(r) continue if single and fromfile: usage(2, "-s and -f don't go together!") good = [] bad = [] skipped = [] resource_denieds = [] if findleaks: try: import gc except ImportError: print 'No GC available, disabling findleaks.' findleaks = False found_garbage = [] if single: gettempdir = gettempdir import tempfile filename = os.path.join(gettempdir(), 'pynexttest') try: fp = open(filename, 'r') next = fp.read().strip() tests = [ next] fp.close() except IOError: pass except: None<EXCEPTION MATCH>IOError None<EXCEPTION MATCH>IOError if fromfile: tests = [] fp = open(fromfile) for line in fp: guts = line.split() if guts and not guts[0].startswith('#'): tests.extend(guts) continue fp.close() if args: args = map(removepy, args) if tests: tests = map(removepy, tests) stdtests = STDTESTS[:] nottests = NOTTESTS[:] if exclude: for arg in args: if arg in stdtests: stdtests.remove(arg) continue nottests[:0] = args args = [] if not tests and args: pass tests = findtests(testdir, stdtests, nottests) if single: tests = tests[:1] if randomize: random.shuffle(tests) if trace: import trace tracer = trace.Trace(ignoredirs = [ sys.prefix, sys.exec_prefix], trace = False, count = True) test_times = [] test_support.verbose = verbose test_support.use_resources = use_resources save_modules = sys.modules.keys() for test in tests: if not quiet: print test sys.stdout.flush() if trace: tracer.runctx('runtest(test, verbose, quiet, test_times, testdir)', globals = globals(), locals = vars()) else: try: ok = runtest(test, verbose, quiet, test_times, testdir, huntrleaks) except KeyboardInterrupt: print break except: raise if ok > 0: good.append(test) elif ok == 0: bad.append(test) else: skipped.append(test) if ok == -2: resource_denieds.append(test) if findleaks: gc.collect() if gc.garbage: print 'Warning: test created', len(gc.garbage), 'uncollectable object(s).' found_garbage.extend(gc.garbage) del gc.garbage[:] for module in sys.modules.keys(): if module not in save_modules and module.startswith('test.'): test_support.unload(module) continue good.sort() bad.sort() skipped.sort() if good and not quiet: if not bad and not skipped and len(good) > 1: print 'All', print count(len(good), 'test'), 'OK.' if print_slow: test_times.sort(reverse = True) print '10 slowest tests:' for time, test in test_times[:10]: print '%s: %.1fs' % (test, time) if bad: print count(len(bad), 'test'), 'failed:' printlist(bad) if skipped and not quiet: print count(len(skipped), 'test'), 'skipped:' printlist(skipped) e = _ExpectedSkips() plat = sys.platform if e.isvalid(): surprise = set(skipped) - e.getexpected() - set(resource_denieds) if surprise: print count(len(surprise), 'skip'), 'unexpected on', plat + ':' printlist(surprise) else: print 'Those skips are all expected on', plat + '.' else: print 'Ask someone to teach regrtest.py about which tests are' print 'expected to get skipped on', plat + '.' if verbose2 and bad: print 'Re-running failed tests in verbose mode' for test in bad: print 'Re-running test %r in verbose mode' % test sys.stdout.flush() try: test_support.verbose = True ok = runtest(test, True, quiet, test_times, testdir, huntrleaks) continue except KeyboardInterrupt: print break continue raise continue if single: alltests = findtests(testdir, stdtests, nottests) for i in range(len(alltests)): if tests[0] == alltests[i]: if i == len(alltests) - 1: os.unlink(filename) else: fp = open(filename, 'w') fp.write(alltests[i + 1] + '\n') fp.close() break continue if trace: r = tracer.results() r.write_results(show_missing = True, summary = True, coverdir = coverdir) if runleaks: os.system('leaks %d' % os.getpid()) sys.exit(len(bad) > 0) STDTESTS = [ 'test_grammar', 'test_opcodes', 'test_dict', 'test_builtin', 'test_exceptions', 'test_types', 'test_unittest', 'test_doctest', 'test_doctest2'] NOTTESTS = [ 'test_support', 'test_future1', 'test_future2'] def findtests(testdir = None, stdtests = STDTESTS, nottests = NOTTESTS): '''Return a list of all applicable test modules.''' if not testdir: testdir = findtestdir() names = os.listdir(testdir) tests = [] for name in names: if name[:5] == 'test_' and name[-3:] == os.extsep + 'py': modname = name[:-3] if modname not in stdtests and modname not in nottests: tests.append(modname) modname not in nottests tests.sort() return stdtests + tests def runtest(test, verbose, quiet, test_times, testdir = None, huntrleaks = False): """Run a single test. test -- the name of the test verbose -- if true, print more messages quiet -- if true, don't print 'skipped' messages (probably redundant) test_times -- a list of (time, test_name) pairs testdir -- test directory huntrleaks -- run multiple times to test for leaks; requires a debug build; a triple corresponding to -R's three arguments Return: -2 test skipped because resource denied -1 test skipped for some other reason 0 test failed 1 test passed """ try: return runtest_inner(test, verbose, quiet, test_times, testdir, huntrleaks) finally: cleanup_test_droppings(test, verbose) def runtest_inner(test, verbose, quiet, test_times, testdir = None, huntrleaks = False): test_support.unload(test) if not testdir: testdir = findtestdir() if verbose: capture_stdout = None else: capture_stdout = cStringIO.StringIO() try: save_stdout = sys.stdout try: if capture_stdout: sys.stdout = capture_stdout if test.startswith('test.'): abstest = test else: abstest = 'test.' + test start_time = time.time() the_package = __import__(abstest, globals(), locals(), []) the_module = getattr(the_package, test) indirect_test = getattr(the_module, 'test_main', None) if indirect_test is not None: indirect_test() if huntrleaks: dash_R(the_module, test, indirect_test, huntrleaks) test_time = time.time() - start_time test_times.append((test_time, test)) finally: sys.stdout = save_stdout except test_support.ResourceDenied: msg = None if not quiet: print test, 'skipped --', msg sys.stdout.flush() return -2 except (ImportError, test_support.TestSkipped): msg = None if not quiet: print test, 'skipped --', msg sys.stdout.flush() return -1 except KeyboardInterrupt: raise except test_support.TestFailed: msg = None print 'test', test, 'failed --', msg sys.stdout.flush() return 0 (type, value) = sys.exc_info()[:2] print 'test', test, 'crashed --', str(type) + ':', value sys.stdout.flush() if verbose: traceback.print_exc(file = sys.stdout) sys.stdout.flush() return 0 if verbose or huntrleaks: return 1 output = capture_stdout.getvalue() if not output: return 1 print 'test', test, 'produced unexpected output:' print '*' * 70 print output print '*' * 70 sys.stdout.flush() return 0 def cleanup_test_droppings(testname, verbose): import shutil for name in (test_support.TESTFN, 'db_home'): if not os.path.exists(name): continue if os.path.isdir(name): kind = 'directory' nuker = shutil.rmtree elif os.path.isfile(name): kind = 'file' nuker = os.unlink else: raise SystemError('os.path says %r exists but is neither directory nor file' % name) if os.path.isdir(name): print '%r left behind %s %r' % (testname, kind, name) try: nuker(name) continue except Exception: msg = None print >>sys.stderr, "%r left behind %s %r and it couldn't be removed: %s" % (testname, kind, name, msg) continue def dash_R(the_module, test, indirect_test, huntrleaks): import copy_reg import _abcoll import io if not hasattr(sys, 'gettotalrefcount'): raise Exception('Tracking reference leaks requires a debug build of Python') hasattr(sys, 'gettotalrefcount') fs = warnings.filters[:] ps = copy_reg.dispatch_table.copy() pic = sys.path_importer_cache.copy() abcs = { } modules = (_abcoll, io) for mod in modules: pass deltas = [] (nwarmup, ntracked, fname) = huntrleaks repcount = nwarmup + ntracked print >>sys.stderr, 'beginning', repcount, 'repetitions' print >>sys.stderr, '1234567890' * (repcount // 10 + 1)[:repcount] dash_R_cleanup(fs, ps, pic, abcs) for i in range(repcount): rc = sys.gettotalrefcount() run_the_test() sys.stderr.write('.') dash_R_cleanup(fs, ps, pic, abcs) if i >= nwarmup: deltas.append(sys.gettotalrefcount() - rc - 2) continue print >>sys.stderr if any(deltas): msg = '%s leaked %s references, sum=%s' % (test, deltas, sum(deltas)) print >>sys.stderr, msg refrep = open(fname, 'a') print >>refrep, msg refrep.close() def dash_R_cleanup(fs, ps, pic, abcs): import gc import copy_reg import _strptime import linecache dircache = test_support.import_module('dircache', deprecated = True) import urlparse import urllib import urllib2 import mimetypes import doctest import struct import filecmp _path_created = _path_created import distutils.dir_util for mod in sys.modules.values(): if hasattr(mod, '__warningregistry__'): del mod.__warningregistry__ continue warnings.filters[:] = fs copy_reg.dispatch_table.clear() copy_reg.dispatch_table.update(ps) sys.path_importer_cache.clear() sys.path_importer_cache.update(pic) sys._clear_type_cache() for abc, registry in abcs.items(): abc._abc_registry = registry.copy() abc._abc_cache.clear() abc._abc_negative_cache.clear() _path_created.clear() re.purge() _strptime._regex_cache.clear() urlparse.clear_cache() urllib.urlcleanup() urllib2.install_opener(None) dircache.reset() linecache.clearcache() mimetypes._default_mime_types() filecmp._cache.clear() struct._clearcache() doctest.master = None gc.collect() def findtestdir(): if __name__ == '__main__': file = sys.argv[0] else: file = __file__ if not os.path.dirname(file): pass testdir = os.curdir return testdir def removepy(name): if name.endswith(os.extsep + 'py'): name = name[:-3] return name def count(n, word): if n == 1: return '%d %s' % (n, word) return '%d %ss' % (n, word) def printlist(x, width = 70, indent = 4): '''Print the elements of iterable x to stdout. Optional arg width (default 70) is the maximum line length. Optional arg indent (default 4) is the number of blanks with which to begin each line. ''' fill = fill import textwrap blanks = ' ' * indent print fill(' '.join(map(str, x)), width, initial_indent = blanks, subsequent_indent = blanks) _expectations = { 'win32': '\n test__locale\n test_bsddb185\n test_bsddb3\n test_commands\n test_crypt\n test_curses\n test_dbm\n test_dl\n test_fcntl\n test_fork1\n test_epoll\n test_gdbm\n test_grp\n test_ioctl\n test_largefile\n test_kqueue\n test_mhlib\n test_openpty\n test_ossaudiodev\n test_pipes\n test_poll\n test_posix\n test_pty\n test_pwd\n test_resource\n test_signal\n test_threadsignals\n test_timing\n test_wait3\n test_wait4\n ', 'linux2': '\n test_bsddb185\n test_curses\n test_dl\n test_largefile\n test_kqueue\n test_ossaudiodev\n ', 'mac': '\n test_atexit\n test_bsddb\n test_bsddb185\n test_bsddb3\n test_bz2\n test_commands\n test_crypt\n test_curses\n test_dbm\n test_dl\n test_fcntl\n test_fork1\n test_epoll\n test_grp\n test_ioctl\n test_largefile\n test_locale\n test_kqueue\n test_mmap\n test_openpty\n test_ossaudiodev\n test_poll\n test_popen\n test_popen2\n test_posix\n test_pty\n test_pwd\n test_resource\n test_signal\n test_sundry\n test_tarfile\n test_timing\n ', 'unixware7': '\n test_bsddb\n test_bsddb185\n test_dl\n test_epoll\n test_largefile\n test_kqueue\n test_minidom\n test_openpty\n test_pyexpat\n test_sax\n test_sundry\n ', 'openunix8': '\n test_bsddb\n test_bsddb185\n test_dl\n test_epoll\n test_largefile\n test_kqueue\n test_minidom\n test_openpty\n test_pyexpat\n test_sax\n test_sundry\n ', 'sco_sv3': '\n test_asynchat\n test_bsddb\n test_bsddb185\n test_dl\n test_fork1\n test_epoll\n test_gettext\n test_largefile\n test_locale\n test_kqueue\n test_minidom\n test_openpty\n test_pyexpat\n test_queue\n test_sax\n test_sundry\n test_thread\n test_threaded_import\n test_threadedtempfile\n test_threading\n ', 'riscos': '\n test_asynchat\n test_atexit\n test_bsddb\n test_bsddb185\n test_bsddb3\n test_commands\n test_crypt\n test_dbm\n test_dl\n test_fcntl\n test_fork1\n test_epoll\n test_gdbm\n test_grp\n test_largefile\n test_locale\n test_kqueue\n test_mmap\n test_openpty\n test_poll\n test_popen2\n test_pty\n test_pwd\n test_strop\n test_sundry\n test_thread\n test_threaded_import\n test_threadedtempfile\n test_threading\n test_timing\n ', 'darwin': '\n test__locale\n test_bsddb\n test_bsddb3\n test_curses\n test_epoll\n test_gdbm\n test_largefile\n test_locale\n test_kqueue\n test_minidom\n test_ossaudiodev\n test_poll\n ', 'sunos5': '\n test_bsddb\n test_bsddb185\n test_curses\n test_dbm\n test_epoll\n test_kqueue\n test_gdbm\n test_gzip\n test_openpty\n test_zipfile\n test_zlib\n ', 'hp-ux11': '\n test_bsddb\n test_bsddb185\n test_curses\n test_dl\n test_epoll\n test_gdbm\n test_gzip\n test_largefile\n test_locale\n test_kqueue\n test_minidom\n test_openpty\n test_pyexpat\n test_sax\n test_zipfile\n test_zlib\n ', 'atheos': '\n test_bsddb185\n test_curses\n test_dl\n test_gdbm\n test_epoll\n test_largefile\n test_locale\n test_kqueue\n test_mhlib\n test_mmap\n test_poll\n test_popen2\n test_resource\n ', 'cygwin': '\n test_bsddb185\n test_bsddb3\n test_curses\n test_dbm\n test_epoll\n test_ioctl\n test_kqueue\n test_largefile\n test_locale\n test_ossaudiodev\n test_socketserver\n ', 'os2emx': '\n test_audioop\n test_bsddb185\n test_bsddb3\n test_commands\n test_curses\n test_dl\n test_epoll\n test_kqueue\n test_largefile\n test_mhlib\n test_mmap\n test_openpty\n test_ossaudiodev\n test_pty\n test_resource\n test_signal\n ', 'freebsd4': '\n test_bsddb\n test_bsddb3\n test_epoll\n test_gdbm\n test_locale\n test_ossaudiodev\n test_pep277\n test_pty\n test_socket_ssl\n test_socketserver\n test_tcl\n test_timeout\n test_urllibnet\n test_multiprocessing\n ', 'aix5': '\n test_bsddb\n test_bsddb185\n test_bsddb3\n test_bz2\n test_dl\n test_epoll\n test_gdbm\n test_gzip\n test_kqueue\n test_ossaudiodev\n test_tcl\n test_zipimport\n test_zlib\n ', 'openbsd3': '\n test_bsddb\n test_bsddb3\n test_ctypes\n test_dl\n test_epoll\n test_gdbm\n test_locale\n test_normalization\n test_ossaudiodev\n test_pep277\n test_tcl\n test_multiprocessing\n ', 'netbsd3': '\n test_bsddb\n test_bsddb185\n test_bsddb3\n test_ctypes\n test_curses\n test_dl\n test_epoll\n test_gdbm\n test_locale\n test_ossaudiodev\n test_pep277\n test_tcl\n test_multiprocessing\n ' } _expectations['freebsd5'] = _expectations['freebsd4'] _expectations['freebsd6'] = _expectations['freebsd4'] _expectations['freebsd7'] = _expectations['freebsd4'] _expectations['freebsd8'] = _expectations['freebsd4'] class _ExpectedSkips: def __init__(self): import os.path as os test_timeout = test_timeout import test self.valid = False if sys.platform in _expectations: s = _expectations[sys.platform] self.expected = set(s.split()) self.expected.add('test_linuxaudiodev') if not os.path.supports_unicode_filenames: self.expected.add('test_pep277') try: test_socket_ssl = test_socket_ssl import test except ImportError: pass if test_socket_ssl.skip_expected: self.expected.add('test_socket_ssl') if test_timeout.skip_expected: self.expected.add('test_timeout') if sys.maxint == 0x7FFFFFFFFFFFFFFFL: self.expected.add('test_imageop') if sys.platform not in ('mac', 'darwin'): MAC_ONLY = [ 'test_macos', 'test_macostools', 'test_aepack', 'test_plistlib', 'test_scriptpackages', 'test_applesingle'] for skip in MAC_ONLY: self.expected.add(skip) elif len(u'\x00'.encode('unicode-internal')) == 4: self.expected.add('test_macostools') if sys.platform != 'win32': WIN_ONLY = [ 'test_unicode_file', 'test_winreg', 'test_winsound', 'test_startfile', 'test_sqlite'] for skip in WIN_ONLY: self.expected.add(skip) if sys.platform != 'irix': IRIX_ONLY = [ 'test_imageop', 'test_al', 'test_cd', 'test_cl', 'test_gl', 'test_imgfile'] for skip in IRIX_ONLY: self.expected.add(skip) if sys.platform != 'sunos5': self.expected.add('test_sunaudiodev') self.expected.add('test_nis') if not sys.py3kwarning: self.expected.add('test_py3kwarn') self.valid = True def isvalid(self): '''Return true iff _ExpectedSkips knows about the current platform.''' return self.valid def getexpected(self): '''Return set of test names we expect to skip on current platform. self.isvalid() must be true. ''' if not self.isvalid(): raise AssertionError return self.expected if __name__ == '__main__': mydir = os.path.abspath(os.path.normpath(os.path.dirname(sys.argv[0]))) i = pathlen = len(sys.path) while i >= 0: i -= 1 if os.path.abspath(os.path.normpath(sys.path[i])) == mydir: del sys.path[i] if len(sys.path) == pathlen: print 'Could not find %r in sys.path to remove it' % mydir main() 
(.txt)